import { readFileSync, writeFileSync } from "node:fs";
import { z } from "zod";

class DeserializationError extends Error {
  constructor(path: string, options?: { cause?: unknown }) {
    super(`Failed to deserialize JSON at "${path}"`, options);
    this.name = "DeserializationError";
  }
}

interface ReadWriteJson {
  read<T>(path: string, schema: z.ZodType<T>): T;
  write<T>(path: string, data: T): void;
}

class JsonFileStore implements ReadWriteJson {
  read<T>(path: string, schema: z.ZodType<T>): T {
    const contents = readFileSync(path, "utf-8");

    let parsed: unknown;
    try {
      parsed = JSON.parse(contents);
    } catch (cause) {
      // The file wasn't valid JSON.
      throw new DeserializationError(path, { cause });
    }

    const result = schema.safeParse(parsed);
    if (!result.success) {
      // The file was valid JSON but didn't match the shape of T.
      throw new DeserializationError(path, { cause: result.error });
    }
    return result.data;
  }

  write<T>(path: string, data: T): void {
    const contents = JSON.stringify(data, null, 2);
    writeFileSync(path, contents, "utf-8");
  }
}

// ---------------------------------------------------------------------------
// Global config schema and types
// ---------------------------------------------------------------------------

export const globalConfigSchema = z.object({
  telemetry: z
    .object({
      enabled: z.boolean().optional(),
      endpoint: z.string().optional(),
      audit: z.boolean().optional(),
    })
    .optional(),
  installationId: z.uuid().optional(),
});

/** Inferred shape of the global config from {@link globalConfigSchema}. */
export type GlobalConfig = z.infer<typeof globalConfigSchema>;

/** Reads and writes global CLI configuration. */
export interface GlobalConfigAccessor {
  /** Returns the current global config. */
  get(): Promise<GlobalConfig>;
  /** Validates and persists a new config. Throws on invalid shape. */
  set(updated: GlobalConfig): Promise<GlobalConfig>;
}

// ---------------------------------------------------------------------------
// Accessor implementation
// ---------------------------------------------------------------------------

export class DefaultGlobalConfigAccessor implements GlobalConfigAccessor {
  constructor(
    private readonly store: ReadWriteJson,
    private readonly path: string,
  ) {}

  async get(): Promise<GlobalConfig> {
    try {
      return this.store.read(this.path, globalConfigSchema);
    } catch (err) {
      if (isFileNotFound(err)) {
        // No config yet (first run, fresh install). An empty object is a
        // valid GlobalConfig because every field in the schema is optional.
        // Or throw some error here.
        return {};
      }
      throw err;
    }
  }

  async set(updated: GlobalConfig): Promise<GlobalConfig> {
    // Even though `updated` is typed as GlobalConfig, we re-validate at
    // runtime: the type is only a compile-time guarantee, and callers can
    // defeat it (e.g. a value cast with `as`, or data that originated as
    // `unknown`). parse() throws a ZodError on invalid shape, satisfying
    // the interface's "throws on invalid shape" contract.
    const validated = globalConfigSchema.parse(updated);
    this.store.write(this.path, validated);
    return validated;
  }
}

function isFileNotFound(err: unknown): boolean {
  return (
    typeof err === "object" &&
    err !== null &&
    "code" in err &&
    (err as { code?: unknown }).code === "ENOENT"
  );
}

const store = new JsonFileStore();
const accessor = new DefaultGlobalConfigAccessor(store, "/path/to/config.json");